package gervosou;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.GregorianCalendar;
import java.util.HashMap;

/**
 * Classe controleur et systeme
 * @author IUT,   A. Front
 * @version 1.0 
 */

public class Controleur implements Serializable{
	
	/**
	 * 
	 */
	//private static final long serialVersionUID = 6136418870870522173L;

	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation
	 * Elle est egalement la classe "application" qui gere l'ensemble des objets de l'appli
	 */	
	// ************************************************************************************************************
		// Attributs
		// ************************************************************************************************************
		private int numDerCompte ;  //Dernier numero de compte (permet de generer automatiquement les numeros de comptes
		private int numDerSociete ;
		
		// Attributs d'Association
		// Ensemble des clients de la banque
		private HashMap<String, ClientPhysique> _clients;
		private HashMap<Integer, ComptePerso> _comptes;
		private HashMap<String, Societe> _societes;
		private HashMap<Integer, CompteSociete> _comptesSocietes;
		private HashMap<String, Mandataires> _mandataires;

		// les differentes fenetres pour chaque fonctionnalite
		private VueMenuBanque _vueMenuBanque = null;
		
		// une seule fenetre est active a la fois; les autres sont null.
		// permet de connaitre l'etat des fenetres de l'interface
		private VueNouvClient _vueNouvClient = null;
		private VueNouvCompte _vueNouvCompte = null;
		private VueConsultComptePerso _vueConsultComptePerso = null;
		private VueDepotArgent _vueDepotArgent = null;
		private VueRetraitArgent _vueRetraitArgent = null;

		private VueNouvelleSociete _vueNouvelleSociete = null;
		private VueNouvCompteSociete _vueNouvCompteSociete = null;
		private VueConsultComptesSociete _vueConsultComptesSociete = null;
		private VueNouvMandat _vueNouvMandat = null;

		// ************************************************************************************************************
		// Constructeur
		// ************************************************************************************************************

		public Controleur() {
			this.setNumDerCompte(0);
			this.setClients(new HashMap<String, ClientPhysique>());
			this.setComptes(new HashMap<Integer, ComptePerso>());
			this.setSocietes(new HashMap<String, Societe>());
			this.setCompteSocietes(new HashMap<Integer, CompteSociete>());
			this.setMandataires(new HashMap<String, Mandataires>());
		} // Fin Controleur

		// ------------------------------------------------------------------------------------------------------------
		// Affecteurs
		
		private void setNumDerCompte(int num){
			numDerCompte = num;
		}
		
		private void setNumDerSociete(int num){
			numDerSociete = num;
		}
		
		/**
		 * Ajoute un client a l'ensemble des clients de la banque.
		 * @param client 	Client a ajouter
		 * @param np 		Nom + Prenom de ce client
		 */
		
		
		private void setClient(ClientPhysique client, String np) {
			this.getClients().put(np, client);
		} // Fin setClient

		
		private void setMandataire(Mandataires m, String np) {
			this.getMandats().put(np, m);
		} // Fin setMandataires
		
		/**
		 * Initialise l'attribut clients a l'ensemble des clients de la banque.
		 * @param clients hashtable de clients a affecter
		 */
		private void setClients(HashMap<String, ClientPhysique> clients) {
			_clients = clients;
		}// Fin setClients
		
		private void setMandataires(HashMap<String, Mandataires> mandataires) {
			_mandataires = mandataires;
		}// Fin setClients
		
		
		/**
		 * Ajoute un compte a l'ensemble des comptes de la banque.
		 * @param compte 	Compte a ajouter
		 * @param n		Numero de ce compte
		 */
		private void setCompte(ComptePerso compte, Integer n) {
			this.getComptes().put(n, compte);
		} // Fin setComptes
		
		private void setSociete(Societe soc, String s) {
			this.getSocietes().put(s, soc);
		}
		
		private void setCompteSociete(CompteSociete cs, Integer n) {
			this.getCompteSocietes().put(n, cs);
		}

		/**
		 * Initialise l'attribut comptes a l'ensemble des comptes de la banque.
		 * @param comptes hashtable de comptes a affecter
		 */
		private void setComptes(HashMap<Integer, ComptePerso> comptes) {
			_comptes = comptes;
		}// Fin setComptes
		
		private void setSocietes(HashMap<String, Societe> societes) {
			_societes = societes;
		}// Fin setSocietes
		
		private void setCompteSocietes(HashMap<Integer, CompteSociete> comptesSocietes) {
			_comptesSocietes = comptesSocietes;
		}
			
		
		/**
		 * Initialise la vue a affecter
		 * @param vue  la vue a affecter
		 */
		private void setVueMenuBanque(VueMenuBanque vue) {
			_vueMenuBanque = vue;
		}// Fin getVueVueMenuBiblio
		
		private void setVueNouvClient(VueNouvClient vue) {
			_vueNouvClient = vue;
		}// Fin setVueVueNouvClient
		
		private void setVueNouvCompte(VueNouvCompte vue) {
			_vueNouvCompte = vue;
		}// Fin setVueVueNouvCompte
		
		private void setVueConsultComptePerso(VueConsultComptePerso vue) {
			_vueConsultComptePerso = vue;
		}
		
		private void setVueNouvelleSociete(VueNouvelleSociete vue) {
			_vueNouvelleSociete = vue;
		}
		
		private void setVueNouvCompteSociete(VueNouvCompteSociete vue) {
			_vueNouvCompteSociete = vue;
		}
		
		private void setVueDepotArgent(VueDepotArgent vue) {
			_vueDepotArgent = vue;
		}
		
		private void setVueRetraitArgent(VueRetraitArgent vue) {
			_vueRetraitArgent = vue;
		}
		
		private void setVueNouvMandat(VueNouvMandat vue) {
			_vueNouvMandat = vue;
		}
		
		private void setVueConsultComptesSociete(VueConsultComptesSociete vue) {
			_vueConsultComptesSociete = vue;
		}
		// ------------------------------------------------------------------------------------------------------------
		// Accesseurs
		
		public int getNumDerCompte(){
			return numDerCompte;
		}
		
		public int getNumDerSociete(){
			return numDerSociete;
		}
		/**
		 * @return ensemble des clients de la banque
		 */
		private HashMap<String, ClientPhysique> getClients() {
			return _clients;
		}// Fin getClients
		
		private HashMap<String, Mandataires> getMandats() {
			return _mandataires;
		}

		/**
		 * Acces a un client par son nom + prenom
		 * @param np 	le nom+prenom du client recherche
		 * @return le client qui a le np indique
		 */
		private ClientPhysique getClient(String np) {
			return this.getClients().get(np);
		} // Fin getClient

		/**
		 * @return ensemble des comptes de la banque
		 */
		private HashMap<Integer, ComptePerso> getComptes() {
			return _comptes;
		}// Fin getCompte
		
		public HashMap<String, Societe> getSocietes() {
			return _societes;
		}
		
		protected HashMap<Integer, CompteSociete> getCompteSocietes() {
			return _comptesSocietes;
		}
		
		private CompteSociete getCompteSociete (int n) {
			return this.getCompteSocietes().get(n);
		}
		
		private Societe getSociete (String s) {
			return this.getSocietes().get(s);				
		}

		/**
		 * Acces a un compte par son numero
		 * @param n 	le numero du compte recherche
		 * @return le compte qui a le numero n
		 */
		private ComptePerso getCompte(Integer n) {
			return this.getComptes().get(n);
		}
		
		private Mandataires getMandat(String np) {
			return this.getMandats().get(np);
		}

		/**
		 * @return la vue  
		 */
		private VueMenuBanque getVueMenuBanque() {
			return _vueMenuBanque ;
		}// Fin getVueVueMenuBanque
		
		private VueNouvClient getVueNouvClient() {
			return _vueNouvClient ;
		}// Fin getVueVueNouvClient
		
		private VueNouvCompte getVueNouvCompte() {
			return _vueNouvCompte ;
		}// Fin getVueVueNouvCompte
		
		private VueConsultComptePerso getVueConsultComptePerso() {
			return _vueConsultComptePerso ;
		}
		
		private VueNouvelleSociete getVueNouvelleSociete() {
			return _vueNouvelleSociete ;
		}
		
		private VueNouvCompteSociete getVueNouvCompteSociete() {
			return _vueNouvCompteSociete ;
		}
		
		private VueDepotArgent getVueDepotArgent() {
			return _vueDepotArgent ;
		}
		
		private VueRetraitArgent getVueRetraitArgent() {
			return _vueRetraitArgent ;
		}
		
		private VueNouvMandat getVueNouvMandat() {
			return _vueNouvMandat;
		}
		
		private VueConsultComptesSociete getVueConsultComptesSociete() {
			return _vueConsultComptesSociete;
		}
		
		// ************************************************************************************************************
		// Methodes publiques de creation et affichage des fenetres de l'application et fermeture
		// ************************************************************************************************************
		/**
		 * Creation et affichage de la fenetre principale de l'application. 
		 * Elle reste affichee
		 */
		
		public void menuBanque() {
			try {this.setVueMenuBanque(new VueMenuBanque(this));	
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		// ************************************************************************************************************
		// Operations liees a l'application en reponse a une action de l'utilisateur dans une vue
		// ************************************************************************************************************
		/**
		 * Creation et affichage de la fenetre de saisie d'un client
		 */
		public void NouvClientPhysique() {
			try {this.setVueNouvClient(new VueNouvClient(this));
			// le Menu est cache
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvClient
				this.getVueNouvClient().setEtat(Vue.initiale);
				this.getVueNouvClient().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		/**
		 * Creation d'un nouveau client 
		 * Invoque dans VueNouvClient
		 * @param  nom, prenom et adresse du client
		 * affiche un message de confirmation apres l'enregistrement ou un message d'erreur 
		 */
		public void nouvClientPhysique(String nom, String prenom, String adresse, String date) {
			// verification de la presence des infos obligatoires
			if ((nom.length() == 0) || (prenom.length() == 0) || (adresse.length() == 0) || (date.length() == 0)){
					Message dialog = new Message("Tous les champs sont obligatoires");
					dialog.setVisible(true);
					}
			else if (this.getClient(nom+prenom)== null) {
				// Instanciation du client
				GregorianCalendar dn = ESDate.lireDate (date);
				if (dn == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					dialog.setVisible(true);
					}
				ClientPhysique clientP = new ClientPhysique(nom, prenom, adresse, dn);
				// Ajout de l'ouvrage dans l'ensemble des clients de la banque
					this.setClient(clientP, nom+prenom);
					
					Message dialog = new Message("Client enregistré");
					dialog.setVisible(true);
					this.fermerVue (this.getVueNouvClient());
					} 
			else {
						Message dialog = new Message("Client déjà existant");
						dialog.setVisible(true);
				}
			}
		
		public void nouvMandataire(String nom, String prenom, String societe, String type) {
			if ((nom.length() == 0) || (prenom.length() == 0) || (societe.length() == 0)) {
				Message dialog = new Message("Tous les champs sont obligatoires");
				dialog.setVisible(true);
				}
		else if (this.getMandat(nom+prenom)== null) {
			
			Mandataires mandat = new Mandataires(nom, prenom, societe);
			// Ajout de l'ouvrage dans l'ensemble des clients de la banque
				this.setMandataire(mandat, nom+prenom);
				
				Message dialog = new Message("Mandataire enregistré");
				dialog.setVisible(true);
				this.fermerVue (this.getVueNouvMandat());
				} 
		else {
				
					Message dialog = new Message("Mandataire déjà existant");
					dialog.setVisible(true);
				    //if (this.getMandat(nom+prenom).getDroits().size() >= 1) {
						
					}
			}
		
		
		/**
		 * Recherche d'un client a partir de son nom et prenom  
		 * Invoque dans VueNouvCompte
		 * @param  le nom et prenom (concatenes) du client
		 * affiche un message d'erreur si le client n'existe pas
		 */
		
		public ClientPhysique rechClientPhysique(String np) {
			ClientPhysique clp = this.getClient(np);
			if (clp == null) {
				Message dialog = new Message("Client inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueNouvCompte
				if (this.getVueNouvCompte() != null) {
				// le controleur modifie l'etat de la vue
					this.getVueNouvCompte().setEtat(Vue.finale);
					this.getVueNouvCompte().alimente(clp);
					}
			}
			return clp;
		} // Fin rechClient
		
		
		public Societe rechSociete(String n) {
			Societe soc = this.getSociete(n);
			if (soc == null) {
				Message dialog = new Message("Société inconnue");
				dialog.setVisible(true);
			}
			else {
					if (this.getVueNouvCompteSociete() != null) {
					this.getVueNouvCompteSociete().setEtat(Vue.finale);
					this.getVueNouvCompteSociete().alimente(soc);
				}
			}
			return soc;
		}
		
		public Societe rechSociete2(String n) {
			Societe soc = this.getSociete(n);
			if (soc == null) {
				Message dialog = new Message("Societe inconnue");
				dialog.setVisible(true);
			}
			else {
				if	(this.getVueConsultComptesSociete() != null) {
					 this.getVueConsultComptesSociete().setEtat(Vue.finale);
					 this.getVueConsultComptesSociete().alimente(soc);
				}
			}
			return soc;
		}
		
		
		public Societe rechMandat(String n) {
			Societe soc = this.getSociete(n);
			if (soc == null) {
			Message dialog = new Message("La société n'a pas de compte");
			dialog.setVisible(true);
			}
			else {
				if(this.getVueNouvMandat() != null) {
				this.getVueNouvMandat().setEtat(Vue.finale);
				this.getVueNouvMandat().alimenteC(soc);
				}
			}
			return soc;
			}
		
		public ComptePerso rechComptePerso(String n) {
			int num = Integer.parseInt(n);
			ComptePerso cp = getCompte(num);
			if (cp == null) {
				Message dialog = new Message("Compte inexistant");
				dialog.setVisible(true);			
			}
			else {
				if (this.getVueConsultComptePerso() != null) {	
					this.getVueConsultComptePerso().setEtat(Vue.finale);
					this.getVueConsultComptePerso().alimente(cp);
				}
				else if (this.getVueDepotArgent() != null) {
					this.getVueDepotArgent().setEtat(Vue.finale);
					this.getVueDepotArgent().alimente(cp);
				}
			}
			return cp;
		}
		
		public ComptePerso rechComptePersoDepot(String n) {
			try {Integer.parseInt(n);
			} catch (Exception e) {
				Message dialogErreur = new Message("Erreur de numéro de compte");
				dialogErreur.setVisible(true);
			}
			
			int num = Integer.parseInt(n);			
			ComptePerso cp = getCompte(num);
			if (cp == null) {
				Message dialog = new Message("Compte inexistant");
				dialog.setVisible(true);			
			}
			else if(this.getVueDepotArgent() != null) {
					this.getVueDepotArgent().setEtat(Vue.finale);
					this.getVueDepotArgent().alimente(cp);
				}
			return cp;
		}
		
		public ComptePerso rechComptePersoRetrait(String n) {
			try {Integer.parseInt(n);
			} catch (Exception e) {
				Message dialogErreur = new Message("Erreur de numéro de compte");
				dialogErreur.setVisible(true);
			}
			
			int num = Integer.parseInt(n);			
			ComptePerso cp = getCompte(num);
			if (cp == null) {
				Message dialog = new Message("Compte inexistant");
				dialog.setVisible(true);			
			}
			else if (this.getVueRetraitArgent() != null){
					this.getVueRetraitArgent().setEtat(Vue.finale);
					this.getVueRetraitArgent().alimente(cp);
				}
			return cp;
		}
		
		public CompteSociete rechCompteSocieteDepot(String n) {
			try {Integer.parseInt(n);
			} catch (Exception e) {
				Message dialogErreur = new Message("Erreur de numéro de compte");
				dialogErreur.setVisible(true);
			}
			
			int num = Integer.parseInt(n);
			CompteSociete cs = getCompteSociete(num);
			if (cs == null) {
				Message dialog = new Message("Compte inexistant");
				dialog.setVisible(true);				
			}
			else if (this.getVueDepotArgent() != null) {
				this.getVueDepotArgent().setEtat(Vue.inter1);
				this.getVueDepotArgent().alimente(cs);
			}
			return cs;
		}
		
		public CompteSociete rechCompteSocieteRetrait(String n) {
			try {Integer.parseInt(n);
			} catch (Exception e) {
				Message dialogErreur = new Message("Erreur de numéro de compte");
				dialogErreur.setVisible(true);
			}
			
			int num = Integer.parseInt(n);
			CompteSociete cs = getCompteSociete(num);
			if (cs == null) {
				Message dialog = new Message("Compte inexistant");
				dialog.setVisible(true);				
			}
			else if (this.getVueRetraitArgent() != null){
				this.getVueRetraitArgent().setEtat(Vue.inter1);
				this.getVueRetraitArgent().alimente(cs);				
			}
			return cs;
		}
		
		public void rechMendataireDepot(String nom, String prenom,
				CompteSociete compteSoc) {
				Mandataires mend = null;/* = compteSoc.getMendataire();
				if(mend.getNom()!=nom || mend.getPrenom()!=prenom){
					Message dialog = new Message("Le mandataire n'existe pas pour cette societe");
					dialog.setVisible(true);
<<<<<<< .mine
					}
			else if (this.getMandataires(nom+prenom)== null) {
				// Instanciation du client
				//Mandataires Mandat = new Mandataires(nom, prenom, NULL);
				Mandataires mandat = new Mandataires(nom, prenom, societe);
				// Ajout de l'ouvrage dans l'ensemble des clients de la banque
					//this.setClient(clientP, nom+prenom);
					this.setMandataire(mandat, nom+prenom);
					
					Message dialog = new Message("Mandataire enregistre");
					dialog.setVisible(true);
					this.fermerVue (this.getVueNouvMandat());
					} 
			else {
						Message dialog = new Message("Mandataire deja present");
						dialog.setVisible(true);
=======
>>>>>>> .r52
				}
				else */ 
				
					Message dialog = new Message("Phase de test : Le dépot est autorisé");
					dialog.setVisible(true);
					this.getVueDepotArgent().setEtat(Vue.finale);
					this.getVueDepotArgent().alimente(compteSoc);			
		}
		
		public void rechMendataireRetrait(String nom, String prenom,
				CompteSociete compteSoc) {
				Mandataires mend = null;/* = compteSoc.getMendataire();
				if(mend.getNom()!=nom || mend.getPrenom()!=prenom){
					Message dialog = new Message("Le mandataire n'existe pas pour cette societe");
					dialog.setVisible(true);
				}
				else */ 
				
					Message dialog = new Message("Phase de test : Le retrait est autorisé");
					dialog.setVisible(true);
					this.getVueRetraitArgent().setEtat(Vue.finale);
					this.getVueRetraitArgent().alimente(compteSoc);			
		}
		

		
		/**
		 * Creation et affichage de la fenetre de saisie d'une societe
		 */ 
		
		public void nouvSociete(String n, String a, String t, String e) {
			if ((n.length()==0) || (a.length()==0) || (t.length()==0) || (e.length()==0)){
				Message dialog = new Message("Tout les champs sont obligatoires");
				dialog.setVisible(true);
			}
			else if (this.getSociete(n)==null){
				Societe soc = new Societe(n, a, t, e);
				this.setSociete(soc, n);
				Message dialog = new Message("Société enregistree");
				dialog.setVisible(true);
				this.fermerVue(this.getVueNouvelleSociete());
			}
			else {
				Message dialog = new Message ("Société déjà existante");
				dialog.setVisible(true);
			}
		}
		
		
		/**
		 * Creation et affichage de la fenetre de saisie d'un compte
		 */ 
		public void NouvComptePerso() {
			try {this.setVueNouvCompte(new VueNouvCompte(this));
			// le Menu est cache
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvCompte
				this.getVueNouvCompte().setEtat(Vue.initiale);
				this.getVueNouvCompte().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void ConsultComptePerso() {
			try {this.setVueConsultComptePerso(new VueConsultComptePerso(this));
			// le Menu est cache
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvCompte
				this.getVueConsultComptePerso().setEtat(Vue.initiale);
				this.getVueConsultComptePerso().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}	
		}
		
		public void NouvSociete(){
			try{this.setVueNouvelleSociete(new VueNouvelleSociete(this));
			this.getVueMenuBanque().getFrame().setVisible(false);
				this.getVueNouvelleSociete().setEtat(Vue.initiale);
				this.getVueNouvelleSociete().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		public void NouvMandat(){
			try{this.setVueNouvMandat(new VueNouvMandat(this));
			this.getVueMenuBanque().getFrame().setVisible(false);
				this.getVueNouvMandat().setEtat(Vue.initiale);
				this.getVueNouvMandat().setVisible(true);
				this.getVueNouvMandat().alimenteS();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		public void NouvCompteSociete(){
			try{this.setVueNouvCompteSociete(new VueNouvCompteSociete(this));
			this.getVueMenuBanque().getFrame().setVisible(false);
				this.getVueNouvCompteSociete().setEtat(Vue.initiale);
				this.getVueNouvCompteSociete().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		public void ConsultComptesSociete() {
			try{this.setVueConsultComptesSociete(new VueConsultComptesSociete(this));
			this.getVueMenuBanque().getFrame().setVisible(false);
				this.getVueConsultComptesSociete().setEtat(Vue.initiale);
				this.getVueConsultComptesSociete().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		

		/**
		 * Creation d'un nouveau compte 
		 * Invoque dans VueNouvCompte
		 * @param  dateEdition la date d'édition de l'ouvrage
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvComptePerso(String ty, String s, String d, ClientPhysique clp) {
			// verification de la presence des infos obligatoires 
			if ((s.length() == 0) || (ty.length() == 0) || (d.length() == 0)){
					Message dialog = new Message("Tous les champs sont obligatoires");
					dialog.setVisible(true);
			}
			else {
				int numero = this.genererNumComptePerso();
				float so = Float.parseFloat(s);
				int dec = Integer.parseInt(d);
				ComptePerso cp = new ComptePerso(numero, ty, so, dec, clp);
				this.setCompte(cp, numero);
				this.getVueNouvCompte().alimenteNum(numero);
				Message dialog = new Message("Compte enregistré");
				dialog.setVisible(true);
				this.fermerVue (this.getVueNouvCompte());
			}
		} // Fin nouvComptePerso
		
		
		public void nouvCompteSociete(String s, Societe soc) {
			
			if ((s.length() == 0)) {
				Message dialog = new Message("Tous les champs sont obligatoires");
				dialog.setVisible(true);
			}
			else {
				int numero = this.genererNumCompteSociete();
				float so = Float.parseFloat(s);
				CompteSociete cs = new CompteSociete(numero, so, soc);
				this.setCompteSociete(cs, numero);
				this.getVueNouvCompteSociete().alimenteNum(numero);
				Message dialog = new Message("Compte enregistré");
				dialog.setVisible(true);
				this.fermerVue ((this.getVueNouvCompteSociete()));
			}
		}
		
		public void DepotArgent() {
			try {this.setVueDepotArgent(new VueDepotArgent(this));
			// le Menu est cache
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvClient
				this.getVueDepotArgent().setEtat(Vue.initiale);
				this.getVueDepotArgent().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void RetraitArgent() {
			try {this.setVueRetraitArgent(new VueRetraitArgent(this));
			// le Menu est cache
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvClient
				this.getVueRetraitArgent().setEtat(Vue.initiale);
				this.getVueRetraitArgent().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void depotSoc(String d, CompteSociete cs) {
			if ((d.length() == 0)){
				Message dialog = new Message("Tous les champs sont obligatoires");
				dialog.setVisible(true);
			}
			else {
				cs.setSolde(cs.getSolde()+Float.parseFloat(d));
				Message dialog = new Message("Dépot d'argent réalisé avec succès \n Nouveau solde :"+cs.getSolde());
				dialog.setVisible(true);
				this.getVueDepotArgent().setEtat(Vue.finale);
				this.getVueDepotArgent().alimente(cs);
				
			}
			
		}
		
		public void depotPers(String d, ComptePerso cp) {
			if ((d.length() == 0)){
				Message dialog = new Message("Tous les champs sont obligatoires");
				dialog.setVisible(true);
			}
			else {
				float so = Float.parseFloat(d);
				so = so+cp.getSolde();
				cp.setSolde(so);
				Message dialog = new Message("Dépot d'argent réalisé avec succès ! Nouveau solde :"+cp.getSolde());
				dialog.setVisible(true);
				this.getVueDepotArgent().setEtat(Vue.finale);
				this.getVueDepotArgent().alimente(cp);
			}
			
		}
		
		/**
		 * Generation d'un numero de compte
		 */
		
		private int genererNumComptePerso() {
			this.setNumDerCompte(this.getNumDerCompte() + 1);
			return(this.getNumDerCompte());
		}
		
		private int genererNumCompteSociete() {
			this.setNumDerSociete(this.getNumDerSociete() + 1);
			return(this.getNumDerSociete());
		}

		public void fermerVue (Vue vue) {
			if (vue instanceof VueMenuBanque ) {	
			// Quitte l'aplication. Sauvegarde les objets du modele
				this.sauve();
				System.exit(0);
				}
			vue.dispose();
			// le Menu est rendu de nouveau visible
			this.getVueMenuBanque().getFrame().setVisible(true);
			this.resetVues();
		}
		
		// Restaure l'etat de l'interface avec seule la fenetre du Menu principal active
		private void resetVues() {
			this.setVueNouvClient (null);
			this.setVueNouvCompte(null);
		}
		
		// ************************************************************************************************************
		// Operations liees a la serialisation des objets de l'application
		// ************************************************************************************************************
		/**
		 *  restauration des objets de l'application
		 */
		public Controleur restaure() {
			try {
				FileInputStream fichier = new FileInputStream("Fsauv.sauv");
				ObjectInputStream in = new ObjectInputStream(fichier);
				return((Controleur) in.readObject());
			} catch (Exception e) {
				Message dialog = new Message("Problème de Restauration ou fichier non crée");
				dialog.setVisible(true);
				return this;
			} 
		}
		
		
		/**
		 *  sauvegarde des objets de l'application
		 */
		private void sauve() {
			try {
				FileOutputStream f = new FileOutputStream("Fsauv.sauv");
				ObjectOutputStream out = new ObjectOutputStream(f);
				out.writeObject(this);
			} catch (Exception e) {
				Message dialog = new Message("Problème de Sauvegarde dans le fichier");
				dialog.setVisible(true);
			}
		}

		public void retraitSoc(String d, CompteSociete cs) {
			if ((d.length() == 0)){
				Message dialog = new Message("Tous les champs sont obligatoires");
				dialog.setVisible(true);
			}
			else {
				if ((cs.getSolde()-Float.parseFloat(d))<0.0) {
					Message dialog = new Message("Retrait impossible ! Solde insufisant ! Retrait maximum :"+cs.getSolde());
					dialog.setVisible(true);}
				else{					
				cs.setSolde(cs.getSolde()-Float.parseFloat(d));
				Message dialog = new Message("Retrait d'argent réalisé avec succès \n Nouveau solde :"+cs.getSolde());
				dialog.setVisible(true);
				this.getVueRetraitArgent().setEtat(Vue.finale);
				this.getVueRetraitArgent().alimente(cs);
				}
				
			}			
		}

		public void retraitPers(String d, ComptePerso cp) {
			if ((d.length() == 0)){
				Message dialog = new Message("Tous les champs sont obligatoires");
				dialog.setVisible(true);
			}
			else if (cp.getSolde()-Float.parseFloat(d)<-cp.getDecouvertAutorise()) {
				Message dialog = new Message("Retrait impossible ! Solde insufisant ! Retrait max :"+(cp.getSolde()+cp.getDecouvertAutorise()));
				dialog.setVisible(true);
			}
			else{				
				cp.setSolde(cp.getSolde()-Float.parseFloat(d));
				Message dialog = new Message("Retrait d'argent réalisé avec succès ! Nouveau solde :"+cp.getSolde());
				dialog.setVisible(true);
				this.getVueRetraitArgent().setEtat(Vue.finale);
				this.getVueRetraitArgent().alimente(cp);
			}			
		}


		
}

